Lookup joins are now generated when the ON filters of a join or the
right-side Select filters imply the partial index predicate.

In several cases, the filters are reduced once implication is proven.
This currently prevents optimal plans from being generated in several
cases, either because unnecessary joins remaining in the expression
tree, or because lookup semi- and anti-joins that should be created are
not. I've left TODOs to denote these cases.

Release note (performance improvement): The optimizer can now use
partial indexes for lookup join operations. This results in potentially
more efficient query plans for joins on tables with partial indexes.

This commit updates `GenerateLookupJoins` to generate lookup semi- and
anti-joins in cases where the columns in the original ON filters are not
covered by the index, but the columns in the filters remaining after
proving filter-predicate implication are covered by the index. This is a
special case only possible for semi- and anti-joins because they never
include columns from the right side of the join in their output columns.
See the comment added in `GenerateLookupJoins` for more details.

Release note (performance improvement): Lookup semi- and anti-joins are
now explored by the optimizer in more cases when the ON filter implies
a partial index predicate. This may lead to more efficient query plans
in some cases.

Previously, when generating a special case of lookup semi/anti-joins on
partial indexes, all columns from the right side of the input join would
be included in the lookup join's columns. These columns were included
even though they were no longer needed (in this special case, the ON
filters have been reduced during filter/predicate implication).

Fetching unnecessary columns was was causing a slight difference between
the estimated cost of a lookup semi/anti-join on a non-partial index
versus a partial index. This is because the coster adds a slight
overhead for each column looked-up by the lookup join.

This commit correctly assigns the lookup join columns in this special
case so that unnecessary columns are not included.

In addition, an assertion has been added to `check_expr.go` (run during
`make testrace`) to catch future mistakes like this. Some tests that
manually build expressions had to be edited to avoid violating this
assertion.

Release note: None